<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=2">
<meta name="theme-color" content="#222">
<meta name="generator" content="Hexo 6.0.0">
  <link rel="apple-touch-icon" sizes="180x180" href="/images/icon.png">
  <link rel="icon" type="image/png" sizes="32x32" href="/images/ficon.png">
  <link rel="icon" type="image/png" sizes="16x16" href="/images/icon.png">
  <link rel="mask-icon" href="/images/icon.png" color="#222">

<link rel="stylesheet" href="/css/main.css">


<link rel="stylesheet" href="/lib/font-awesome/css/all.min.css">
  <link rel="stylesheet" href="/lib/pace/pace-theme-minimal.min.css">
  <script src="/lib/pace/pace.min.js"></script>

<script id="hexo-configurations">
    var NexT = window.NexT || {};
    var CONFIG = {"hostname":"bqlin.github.io","root":"/","scheme":"Gemini","version":"7.8.0","exturl":false,"sidebar":{"position":"left","display":"post","padding":18,"offset":12,"onmobile":false},"copycode":{"enable":false,"show_result":false,"style":null},"back2top":{"enable":true,"sidebar":false,"scrollpercent":false},"bookmark":{"enable":false,"color":"#222","save":"auto"},"fancybox":false,"mediumzoom":false,"lazyload":false,"pangu":true,"comments":{"style":"tabs","active":"gitalk","storage":true,"lazyload":false,"nav":{"gitalk":{"order":-2}},"activeClass":"gitalk"},"algolia":{"hits":{"per_page":10},"labels":{"input_placeholder":"Search for Posts","hits_empty":"We didn't find any results for the search: ${query}","hits_stats":"${hits} results found in ${time} ms"}},"localsearch":{"enable":true,"trigger":"auto","top_n_per_article":-1,"unescape":false,"preload":false},"motion":{"enable":false,"async":true,"transition":{"post_block":"fadeIn","post_header":"slideDownIn","post_body":"slideDownIn","coll_header":"slideLeftIn","sidebar":"slideUpIn"}},"path":"search.xml"};
  </script>

  <meta name="description" content="有很多方法可以调整现有的线程代码，以利用Grand Central Dispatch和操作对象的优势。虽然不是在所有情况下都能摆脱线程，但在你进行转换的地方，性能（以及代码的简单性）可以得到极大的改善。具体来说，使用调度队列和操作队列而取代线程有几个优势：">
<meta property="og:type" content="article">
<meta property="og:title" content="Concurrency Programming Guide：迁移线程代码">
<meta property="og:url" content="https://bqlin.github.io/posts/concurrency_pg_migrating_away_from_threads/index.html">
<meta property="og:site_name" content="權咚领域">
<meta property="og:description" content="有很多方法可以调整现有的线程代码，以利用Grand Central Dispatch和操作对象的优势。虽然不是在所有情况下都能摆脱线程，但在你进行转换的地方，性能（以及代码的简单性）可以得到极大的改善。具体来说，使用调度队列和操作队列而取代线程有几个优势：">
<meta property="og:locale" content="zh_CN">
<meta property="article:published_time" content="2021-09-08T09:44:58.000Z">
<meta property="article:modified_time" content="2021-10-24T04:12:53.000Z">
<meta property="article:author" content="權咚">
<meta property="article:tag" content="Apple">
<meta property="article:tag" content="多线程">
<meta property="article:tag" content="Concurrency Programming Guide">
<meta name="twitter:card" content="summary">

<link rel="canonical" href="https://bqlin.github.io/posts/concurrency_pg_migrating_away_from_threads/">


<script id="page-configurations">
  // https://hexo.io/docs/variables.html
  CONFIG.page = {
    sidebar: "",
    isHome : false,
    isPost : true,
    lang   : 'zh-CN'
  };
</script>

  <title>Concurrency Programming Guide：迁移线程代码 | 權咚领域</title>
  
    <script async src="https://www.googletagmanager.com/gtag/js?id=UA-105338942-1"></script>
    <script>
      if (CONFIG.hostname === location.hostname) {
        window.dataLayer = window.dataLayer || [];
        function gtag(){dataLayer.push(arguments);}
        gtag('js', new Date());
        gtag('config', 'UA-105338942-1');
      }
    </script>


  <script>
    var _hmt = _hmt || [];
    (function() {
      var hm = document.createElement("script");
      hm.src = "https://hm.baidu.com/hm.js?98fcf61fd269408d07dcbc1e49311f9a";
      var s = document.getElementsByTagName("script")[0];
      s.parentNode.insertBefore(hm, s);
    })();
  </script>




  <noscript>
  <style>
  .use-motion .brand,
  .use-motion .menu-item,
  .sidebar-inner,
  .use-motion .post-block,
  .use-motion .pagination,
  .use-motion .comments,
  .use-motion .post-header,
  .use-motion .post-body,
  .use-motion .collection-header { opacity: initial; }

  .use-motion .site-title,
  .use-motion .site-subtitle {
    opacity: initial;
    top: initial;
  }

  .use-motion .logo-line-before i { left: initial; }
  .use-motion .logo-line-after i { right: initial; }
  </style>
</noscript>

<link rel="alternate" href="/atom.xml" title="權咚领域" type="application/atom+xml">
</head>

<body itemscope itemtype="http://schema.org/WebPage">
  <div class="container">
    <div class="headband"></div>

    <header class="header" itemscope itemtype="http://schema.org/WPHeader">
      <div class="header-inner"><div class="site-brand-container">
  <div class="site-nav-toggle">
    <div class="toggle" aria-label="切换导航栏">
      <span class="toggle-line toggle-line-first"></span>
      <span class="toggle-line toggle-line-middle"></span>
      <span class="toggle-line toggle-line-last"></span>
    </div>
  </div>

  <div class="site-meta">

    <a href="/" class="brand" rel="start">
      <span class="logo-line-before"><i></i></span>
      <h1 class="site-title">權咚领域</h1>
      <span class="logo-line-after"><i></i></span>
    </a>
      <p class="site-subtitle" itemprop="description">Making app a work of art.</p>
  </div>

  <div class="site-nav-right">
    <div class="toggle popup-trigger">
        <i class="fa fa-search fa-fw fa-lg"></i>
    </div>
  </div>
</div>




<nav class="site-nav">
  <ul id="menu" class="main-menu menu">
        <li class="menu-item menu-item-home">

    <a href="/" rel="section"><i class="fa fa-home fa-fw"></i>首页</a>

  </li>
        <li class="menu-item menu-item-archives">

    <a href="/archives/" rel="section"><i class="fa fa-archive fa-fw"></i>归档</a>

  </li>
        <li class="menu-item menu-item-tags">

    <a href="/tags/" rel="section"><i class="fa fa-tags fa-fw"></i>标签</a>

  </li>
        <li class="menu-item menu-item-categories">

    <a href="/categories/" rel="section"><i class="fa fa-th fa-fw"></i>分类</a>

  </li>
        <li class="menu-item menu-item-about">

    <a href="/about/" rel="section"><i class="fa fa-user fa-fw"></i>关于</a>

  </li>
      <li class="menu-item menu-item-search">
        <a role="button" class="popup-trigger"><i class="fa fa-search fa-fw"></i>搜索
        </a>
      </li>
  </ul>
</nav>



  <div class="search-pop-overlay">
    <div class="popup search-popup">
        <div class="search-header">
  <span class="search-icon">
    <i class="fa fa-search"></i>
  </span>
  <div class="search-input-container">
    <input autocomplete="off" autocapitalize="off"
           placeholder="搜索..." spellcheck="false"
           type="search" class="search-input">
  </div>
  <span class="popup-btn-close">
    <i class="fa fa-times-circle"></i>
  </span>
</div>
<div id="search-result">
  <div id="no-result">
    <i class="fa fa-spinner fa-pulse fa-5x fa-fw"></i>
  </div>
</div>

    </div>
  </div>

</div>
    </header>

    
  <div class="back-to-top">
    <i class="fa fa-arrow-up"></i>
    <span>0%</span>
  </div>


    <main class="main">
      <div class="main-inner">
        <div class="content-wrap">
          

          <div class="content post posts-expand">
            

    
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://bqlin.github.io/posts/concurrency_pg_migrating_away_from_threads/">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/images/icon.png">
      <meta itemprop="name" content="權咚">
      <meta itemprop="description" content="🤘🤯👾">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="權咚领域">
    </span>
      <header class="post-header">
        <h1 class="post-title" itemprop="name headline">
          Concurrency Programming Guide：迁移线程代码
        </h1>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2021-09-08 17:44:58" itemprop="dateCreated datePublished" datetime="2021-09-08T17:44:58+08:00">2021-09-08</time>
            </span>
              <span class="post-meta-item">
                <span class="post-meta-item-icon">
                  <i class="far fa-calendar-check"></i>
                </span>
                <span class="post-meta-item-text">更新于</span>
                <time title="修改时间：2021-10-24 12:12:53" itemprop="dateModified" datetime="2021-10-24T12:12:53+08:00">2021-10-24</time>
              </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/categories/%E7%BF%BB%E8%AF%91/" itemprop="url" rel="index"><span itemprop="name">翻译</span></a>
                </span>
            </span>

          
            <span class="post-meta-item" title="阅读次数" id="busuanzi_container_page_pv" style="display: none;">
              <span class="post-meta-item-icon">
                <i class="fa fa-eye"></i>
              </span>
              <span class="post-meta-item-text">阅读次数：</span>
              <span id="busuanzi_value_page_pv"></span>
            </span><br>
            <span class="post-meta-item" title="本文字数">
              <span class="post-meta-item-icon">
                <i class="far fa-file-word"></i>
              </span>
                <span class="post-meta-item-text">本文字数：</span>
              <span>7.8k</span>
            </span>
            <span class="post-meta-item" title="阅读时长">
              <span class="post-meta-item-icon">
                <i class="far fa-clock"></i>
              </span>
                <span class="post-meta-item-text">阅读时长 &asymp;</span>
              <span>7 分钟</span>
            </span>

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
        <p>有很多方法可以调整现有的线程代码，以利用Grand Central Dispatch和操作对象的优势。虽然不是在所有情况下都能摆脱线程，但在你进行转换的地方，性能（以及代码的简单性）可以得到极大的改善。具体来说，使用调度队列和操作队列而取代线程有几个优势：</p>
<span id="more"></span>
<ul>
<li>减少了程序为在内存空间中存储线程堆栈的内存占用。</li>
<li>消除了创建和配置线程所需的代码。</li>
<li>消除了管理和安排线程工作所需的代码。</li>
<li>减少了代码量。</li>
</ul>
<p>本章提供了一些技巧和指南，说明如何替换现有的基于线程的代码，转而使用调度队列和操作队列来实现相同类型的行为。</p>
<h2 id="用调度队列替换线程">用调度队列替换线程</h2>
<p>要了解如何用调度队列替换线程，首先要考虑在程序中使用线程的一些方式：</p>
<ul>
<li><strong>单一任务线程</strong>。创建一个线程来执行一个单一的任务，当任务完成后释放该线程。</li>
<li><strong>工作线程</strong>。创建一个或多个工作线程，每个线程都有特定的任务。定期向每个线程调度任务。</li>
<li><strong>线程池</strong>。创建一个通用线程池，并为每个线程设置run loop。当你有任务要执行时，从池子里取一个线程，把任务调度给它。如果没有空闲的线程，就把任务排入队列，等待可用的线程。</li>
</ul>
<p>尽管这些看起来是截然不同的技术，但它们实际上只是同一原则的变种。在以上的每种使用方式，线程都被用来运行程序必须执行的一些任务。它们之间唯一的区别是用于管理线程和任务队列的代码。通过使用调度队列和操作队列，可以消除所有线程和线程通信的代码，让你专注于要执行的任务。</p>
<p>如果你正在使用上述线程模型，你应该和清楚程序要执行任务类型。与其将一个任务提交给你的一个自定义线程，不如尝试将该任务封装在一个操作对象或一个block对象中，并将其调度到适当的队列中。对于那些不是特别有争议的任务（不需要锁的任务），你应该能进行以下的直接替换：</p>
<ul>
<li>对于单个任务线程，将任务封装在一个block或操作对象中，并将其提交给一个并发队列。</li>
<li>对于工作线程，你需要决定是使用一个串行队列还是一个并发队列。如果你使用工作现场来同步执行特定的任务集，请使用串行队列。如果你确实使用工作现场来执行没有相互依赖关系的任意任务，则使用并发队列。</li>
<li>对于线程池，将你的任务封装在一个block或操作对象中，并将它们调度到一个并发队列中执行。</li>
</ul>
<p>当然，像这样简单的替换可能并不是在所有情况下都适用。如果你正在执行的任务存在争夺共享资源，理想的解决方案是首先尝试消除或尽量减少这种争夺。如果你有办法重构你的代码以消除对共享资源的相互依赖，这当然是最好的。但是，如果做不到，或者效率较低，那么还是有办法利用队列的优势。队列的一大优势是，它们提供了一种更可预测的方式来执行你的代码。这种可预测性意味着仍有办法在不使用锁或其他重量级同步机制的情况下同步执行你的代码。你可以使用队列来执行许多相同的任务，而不是使用锁。</p>
<ul>
<li>如果是必须按特定顺序执行的任务，可以把它们提交给一个串行调度队列。或使用操作对象依赖来确保以特定的顺序执行。</li>
<li>如果目前使用锁来保护一个共享资源，创建一个串行队列来执行任何修改该资源的任务。然后，使用串行队列将取代现有的锁作为同步机制的代码。关于摆脱锁的更多技术，可参阅<a target="_blank" rel="noopener" href="https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/ThreadMigration/ThreadMigration.html#//apple_ref/doc/uid/TP40008091-CH105-SW3">Eliminating Lock-Based Code</a>。</li>
<li>如果在用线程连接来等待后台任务的完成，可以考虑使用调度组来替换。也可以使用<code>NSBlockOperation</code>对象或操作对象依赖来实现类似的组完成行为。关于如何跟踪执行任务的组，可参阅<a target="_blank" rel="noopener" href="https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/ThreadMigration/ThreadMigration.html#//apple_ref/doc/uid/TP40008091-CH105-SW6">Replacing Thread Joins</a>。</li>
<li>如果在使用生产者-消费者算法来管理有限资源池，可以考虑将实现改为<a target="_blank" rel="noopener" href="https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/ThreadMigration/ThreadMigration.html#//apple_ref/doc/uid/TP40008091-CH105-SW7">修改生产者-消费者实现</a>中所述的方案。</li>
<li>如果在使用线程从描述符中读写，或监视文件操作，可以改用调度源实现。</li>
</ul>
<p>重要的是要记住，队列并不是取代线程的万金油。队列提供的异步编程模型适用于允许延迟的场景。即使队列提供了配置任务执行优先级的方法，但较高的执行优先级并不能保证任务在特定的时间执行。因此，在需要尽可能避免延迟的情况下，线程仍然是一个更合适的选择，例如在音频和视频播放的场景。</p>
<h2 id="消除基于锁的代码">消除基于锁的代码</h2>
<p>对于线程代码，锁是同步访问线程间共享资源的传统方式之一。然而，锁的使用是有代价的。即使在无竞态条件的情况下，使用锁也会有性能损失。而在竞态条件的情况下，一或多个线程有可能在等待锁被释放的过程中阻塞不确定的时间。</p>
<p>用队列取代基于锁的代码，可以消除许多与锁相关的损耗，同时也简化了剩余的代码。你可以创建一个队列来串行访问该资源，而不是使用锁来保护一个共享资源。队列不会像锁那样带来性能损耗。例如，排队的任务不需要进入内核来获取互斥锁。</p>
<p>当排队任务时，你只需决定是同步还是异步进行。异步提交任务可以让当前线程在执行任务时继续运行。同步提交任务则会阻塞当前线程的运行，直到任务完成。这两个情况都有适当的用途，但只要有可能，异步提交任务肯定是更优的。</p>
<p>下面几节将向你展示如何用等价的基于队列的代码来替换现有的基于锁的代码。</p>
<h3 id="实现异步锁">实现异步锁</h3>
<p>异步锁是一种保护共享资源的方式，它不会阻塞任何修改该资源的代码。当你需要修改一个数据结构，会影响其他的任务时，你可能会使用异步锁。使用传统的线程，通常的方式是为共享资源加锁，然后进行必要的修改，释放锁，然后继续完成任务。然而，使用调度队列，调用的代码可以异步地进行修改，而不必等待这些修改完成。</p>
<p>清单5-1显示了一个异步锁实现的例子。在这个例子中，受保护的资源定义了自己的串行调度队列。调用代码向这个队列提交一个block对象，其中包含需要对资源进行的修改。因为队列本身是串行执行block的，所以对资源的修改保证按照接收的顺序进行；但是，因为任务是异步执行的，所以调用线程不会阻塞。</p>
<p><strong>清单5-1</strong> 异步修改保护的资源</p>
<figure class="highlight objc"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">dispatch_async</span>(obj-&gt;serial_queue, ^&#123;</span><br><span class="line">   <span class="comment">// Critical section</span></span><br><span class="line">&#125;);</span><br></pre></td></tr></table></figure>
<h3 id="同步执行关键代码">同步执行关键代码</h3>
<p>如果当前的代码在某个任务完成之前不能继续，你可以使用<code>dispatch_sync</code>函数同步提交该任务。这个函数将任务添加到一个调度队列中，然后阻塞当前线程，直到任务执行完毕。根据你的需要，调度队列本身可以是一个串行或并发队列。因为这个函数会阻塞当前线程，所以你应该只在必要时使用它。清单5-2显示了使用<code>dispatch_sync</code>来包装代码的关键部分的技术。</p>
<p><strong>清单5-2</strong> 同步执行关键代码</p>
<figure class="highlight objc"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">dispatch_sync</span>(my_queue, ^&#123;</span><br><span class="line">   <span class="comment">// Critical section</span></span><br><span class="line">&#125;);</span><br></pre></td></tr></table></figure>
<p>如果你已经在使用一个串行队列来保护共享资源，同步调度到该队列并不会比异步调度更能保护共享资源。使用同步调度的是为了阻塞当前代码，直到关键部分完成。例如，如果你想从共享资源中获取一些值并立即使用它，你就需要同步调度。如果当前代码不需要等待关键部分的完成，或者它可以简单地提交后续任务到同一个串行队列中，那么异步提交往往是首选。</p>
<h2 id="改进循环代码">改进循环代码</h2>
<p>如果代码有循环，并且每次通过循环所做的工作与其他迭代中的工作无关，你可以考虑使用<code>dispatch_apply</code>或<code>dispatch_apply_f</code>函数重新实现该循环代码。这些函数把循环的每个迭代单独提交给一个调度队列进行处理。当与并发队列一起使用时，这个功能可以让你并发地执行循环迭代。</p>
<p>如果你的循环的每次迭代都是相互独立的话，你也许应该考虑使用 <code>dispatch_apply</code> 或 <code>dispatch_apply_f</code> 重新实现你的循环。这两个函数将每个迭代提交给队列处理。当和并行队列一起使用的时候，这个特性让你能够同时进行多个迭代。</p>
<p><code>dispatch_apply</code>和<code>dispatch_apply_f</code>函数是同步函数调用，它们会阻塞当前执行线程，直到所有的循环迭代完成。当提交给一个并发队列时，循环迭代的执行顺序不被保证。运行每个迭代的线程可能会阻塞，导致一个给定的迭代在它周围的其他迭代之前或之后完成。因此，在为每个循环迭代使用的block对象或函数必须是可重入的。</p>
<p>清单5-3显示了如何用基于GCD来替换for循环。传递给<code>dispatch_apply</code>或<code>dispatch_apply_f</code>的block或函数必须取一个整数值，表示当前循环的迭代。在这个例子中，代码只是将当前的循环编号打印到控制台。</p>
<p><strong>清单5-3</strong> 逐步替换for循环</p>
<figure class="highlight objc"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, <span class="number">0</span>);</span><br><span class="line">dispatch_apply(count, queue, ^(size_t i) &#123;</span><br><span class="line">   printf(<span class="string">&quot;%u\n&quot;</span>, i);</span><br><span class="line">&#125;);</span><br></pre></td></tr></table></figure>
<p>尽管前面的例子是一个简单的例子，但它展示了使用调度队列替换循环的基本技术。尽管这可能是提高基于循环的代码性能的一个好方法，但你仍必须辨证地使用这种技术。尽管调度队列的开销很低，但在一个线程上调度每个循环迭代仍有成本。因此，你应该确保你的循环代码做了足够多的工作来抵消这些成本。确切地说，需要做多少工作是你必须使用性能工具来衡量的事情。</p>
<p>增加每个循环迭代的工作量的一个简单方法是使用striding。使用striding重写你的block，以每次执行原始循环的多个迭代。然后，将指定给<code>dispatch_apply</code>函数的计数值按比例减少。清单5-4显示了如何为清单5-3中的循环代码实现striding。在清单5-4中，该block调用<code>printf</code>语句的次数与stride值相同，在本例中是137。(实际的stride值是你应该根据你的代码所做的工作来配置的)。因为在将总的迭代次数除以stride值时，会有剩余的部分，所以任何剩余的迭代都是直接执行的。</p>
<p><strong>清单5-4</strong> 向调度的for循环增加步幅</p>
<figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line">int stride = 137;</span><br><span class="line">dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);</span><br><span class="line"> </span><br><span class="line">dispatch_apply(count / stride, queue, ^(size_t idx)&#123;</span><br><span class="line">    size_t j = idx * stride;</span><br><span class="line">    size_t j_stop = j + stride;</span><br><span class="line">    do &#123;</span><br><span class="line">       printf(&quot;%u\n&quot;, (unsigned int)j++);</span><br><span class="line">    &#125;while (j &lt; j_stop);</span><br><span class="line">&#125;);</span><br><span class="line"> </span><br><span class="line">size_t i;</span><br><span class="line">for (i = count - (count % stride); i &lt; count; i++)</span><br><span class="line">   printf(&quot;%u\n&quot;, (unsigned int)i);</span><br></pre></td></tr></table></figure>
<p>使用stride有一些明确的性能优势。尤其是当原始循环迭代次数较多时。同时调度较少的block意味着花在执行这些block的代码上的时间比调度它们的时间多。不过和任何性能指标一样，你可能要调整striding的值来达到最佳性能。</p>
<h2 id="替换线程连接">替换线程连接</h2>
<p>线程连接允许你生成一个或多个线程，然后让当前线程等待，直到这些线程完成。为了实现线程连接，一个父线程会创建一个子线程作为<em>可连接线程</em>。当父线程在没有子线程的结果的情况下不能再取得进展时，它就与子线程连接。这个过程会阻塞父线程，直到子线程完成其任务并退出，这时，父线程可以从子线程中收集结果并继续原来的工作。如果父线程需要与多个子线程连接，它只能逐个进行。</p>
<p>调度组提供了类似于线程连接的语义，但也有一些额外的优势。与线程连接一样，调度组是一种让线程阻塞的方式，直到一个或多个子任务执行完毕。与线程连接不同，调度组同时等待其所有子任务。因为调度组使用调度队列来执行工作，所以它们非常高效。</p>
<p>要使用调度组来执行由可连接线程执行的相同工作，你要做的是：</p>
<ol type="1">
<li>使用<code>dispatch_group_create</code>函数创建一个调度组。</li>
<li>使用<code>dispatch_group_async</code>或<code>dispatch_group_async_f</code>函数向该组添加任务。提交给组的每个任务都表示在一个可加入的线程上执行的工作。</li>
<li>当当前线程不能再向前推进时，调用<code>dispatch_group_wait</code>函数来等待该组。这个函数会阻止当前线程，直到该组中的所有任务完成执行。</li>
</ol>
<p>如果你使用操作对象来实现你的任务，你也可以使用依赖关系实现线程连接。与其让一个父线程等待一个或多个任务完成，不如将父线程的代码移到一个操作对象中。然后，你将在父操作对象和任何数量的子操作对象之间建立依赖关系，以完成通常由可连接线程执行的工作。对其他操作对象的依赖关系可以阻塞父操作对象的执行，直到所有的操作都完成。</p>
<p>关于如何使用调度组的例子，可参阅<a target="_blank" rel="noopener" href="https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationQueues/OperationQueues.html#//apple_ref/doc/uid/TP40008091-CH102-SW25">Waiting on Groups of Queued Tasks</a>。关于设置操作对象之间的依赖关系，可参阅<a target="_blank" rel="noopener" href="https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationObjects/OperationObjects.html#//apple_ref/doc/uid/TP40008091-CH101-SW17">Configuring Interoperation Dependencies</a>。</p>
<h2 id="改变生产者-消费者的实现方式">改变生产者-消费者的实现方式</h2>
<p>生产者-消费者模型可以让你管理有限动态生产的资源。当生产者创建新的资源（或任务）时，一个或多个消费者等待这些资源（或任务）就绪，并在它们就绪时消费它们。实现生产者-消费者模型的典型机制是条件（conditions）或信号量。</p>
<p>使用条件，生产者线程通常做以下事情：</p>
<ol type="1">
<li>锁定与条件相关的互斥锁（使用<code>pthread_mutex_lock</code>）。</li>
<li>生产将被消费的资源或任务。</li>
<li>向条件变量发出信号，表示有资源要消耗（使用<code>pthread_cond_signal</code>）。</li>
<li>解锁互斥锁（使用<code>pthread_mutex_unlock</code>）。</li>
</ol>
<p>相应的消费线程会做以下事情：</p>
<ol type="1">
<li>锁定与该条件相关的互斥锁（使用<code>pthread_mutex_lock</code>）。</li>
<li>设置一个<code>while</code>循环，做以下工作：
<ol type="1">
<li>检查是否真的有任务要执行。</li>
<li>如果没有任务要执行（或者没有可用的资源），调用<code>pthread_cond_wait</code>来阻塞当前线程，直到有相应的信号量出现。</li>
</ol></li>
<li>获取生产者提供的任务（或资源）。</li>
<li>解锁互斥锁（使用<code>pthread_mutex_unlock</code>）。</li>
<li>处理任务。</li>
</ol>
<p>通过调度队列，你可以将生产者和消费者的实现简化为单一的调用：</p>
<figure class="highlight objc"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">dispatch_async</span>(queue, ^&#123;</span><br><span class="line">   <span class="comment">// Process a work item.</span></span><br><span class="line">&#125;);</span><br></pre></td></tr></table></figure>
<p>当你的生产者有任务要执行时，它所要做的就是将该任务添加到队列中，让队列处理该任务。前面的代码中唯一改变的部分是队列类型。如果生产者生成的任务需要按照特定的顺序执行，就使用一个串行队列。如果生产者生成的任务可以并发执行，就把它们添加到一个并发队列中，让系统尽可能地同时执行它们。</p>
<h2 id="替换信号量代码">替换信号量代码</h2>
<p>如果你目前在使用信号量来限制对共享资源的访问，你应考虑使用调度信号量来代替。传统的信号量总是需要调用内核来测试信号量。相反，调度信号量在用户空间中快速测试信号量的状态，并且只有在测试失败和调用线程需要被阻塞时才会进入内核。这种行为的结果是，在没有竞态条件的情况下，调度信号量比传统信号量快得多。不过在其他方面，调度信号量提供了与传统信号量相同的行为。</p>
<p>关于如何使用调度信号的例子，可参阅<a target="_blank" rel="noopener" href="https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationQueues/OperationQueues.html#//apple_ref/doc/uid/TP40008091-CH102-SW24">Using Dispatch Semaphores to Regulate the Use of Finite Resources</a>。</p>
<h2 id="替换run-loop代码">替换Run-Loop代码</h2>
<p>如果你正在使用run loop来管理一个或多个线程上执行的工作，你可能会发现队列的实现和维护要简单得多。设置一个自定义的run loop包括设置底层线程和run loop本身。run loop的代码包括设置一个或多个run loop源，并编写回调来处理到达这些源的事件。所有的这些，你可以简单地创建一个串行队列，并向其调度任务。因此，你可以用一行代码取代所有的线程和run loop创建代码。</p>
<figure class="highlight objc"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">dispatch_queue_t</span> myNewRunLoop = dispatch_queue_create(<span class="string">&quot;com.apple.MyQueue&quot;</span>, <span class="literal">NULL</span>);</span><br></pre></td></tr></table></figure>
<p>因为队列会自动执行添加的任务，所以你不需要额外的代码来管理队列。你不需要创建或配置线程，也不需要创建或附加任何run loop源。此外，你可以通过简单地将任务添加到队列中来执行新的工作类型。要对run loop做同样的事情，你需要修改你现有的run loop源或创建一个新的run loop源来处理新的数据。</p>
<p>run loop的一个常见配置是处理异步到达网络套接字上的数据。与其为这种类型的行为配置一个run loop，你可以为所需的队列附加一个调度源。与传统的run loop源相比，调度源还提供了更多处理数据的选项。除了处理定时器和网络端口事件外，你还可以使用调度源来读写文件、监控文件系统对象、监控进程和监控信号。你甚至可以定义自定义调度源，从你代码的其他部分异步触发它们。关于设置调度源的更多信息，可参阅<a href=".%2F04%20Dispatch%20Sources.md">调度源</a>。</p>
<h2 id="兼容posix线程">兼容POSIX线程</h2>
<p>由于Grand Central Dispatch管理着你提供的任务和这些任务运行的线程之间的关系，你一般应该避免从你的任务代码中调用POSIX线程例程。如果你因为某些原因需要调用它们，你应该非常小心地对待你所调用的例程（routines）。本节为你提供了一个指南，说明哪些例程可以安全调用，哪些例程不可以从你的队列任务中调用。这个列表并不完整，但应该给你一个指示，哪些是安全的调用，哪些是不安全的。</p>
<p>一般来说，程序不能删除或改变不是它创建的对象或数据结构。因此，使用调度队列执行的block对象不能调用以下函数：</p>
<ul>
<li><code>pthread_detach</code></li>
<li><code>pthread_cancel</code></li>
<li><code>pthread_join</code></li>
<li><code>pthread_kill</code></li>
<li><code>pthread_exit</code></li>
</ul>
<p>尽管在任务运行时是可以修改一个线程的状态的，但你必须在你的任务返回之前将线程返回到它的原始状态。因此，只要你把线程返回到它的原始状态，调用以下函数是安全的：</p>
<ul>
<li><code>pthread_setcancelstate</code></li>
<li><code>pthread_setcanceltype</code></li>
<li><code>pthread_setschedparam</code></li>
<li><code>pthread_sigmask</code></li>
<li><code>pthread_setspecific</code></li>
</ul>
<p>用于执行一个给定block的底层线程可以在不同的调用中进行修改。因此，程序不应该依赖以下函数在block的调用之间返回可预测的结果：</p>
<ul>
<li><code>pthread_self</code></li>
<li><code>pthread_getschedparam</code></li>
<li><code>pthread_get_stacksize_np</code></li>
<li><code>pthread_get_stackaddr_np</code></li>
<li><code>pthread_mach_thread_np</code></li>
<li><code>pthread_from_mach_thread_np</code></li>
<li><code>pthread_getspecific</code></li>
</ul>
<p><strong>重要提醒：</strong>block必须捕获并抑制在其中抛出的任何语言级异常。在block的执行过程中发生的其他错误同样应该由block来处理，或者用来通知程序的其他部分。</p>
<p>关于POSIX线程和本节中提到的函数的更多信息，可参阅<code>pthread</code> man pages。</p>
<h2 id="总结">总结</h2>
<ul>
<li>异步添加任务到串行队列实现了异步锁。</li>
<li>关键代码使用同步方式进入串行、并发队列中执行。</li>
<li>用调度组替换线程连接。</li>
<li>生产者-消费者模型可以直接用给队列添加任务实现。如果生产者生成的任务需要按照特定的顺序执行，就使用一个串行队列。如果生产者生成的任务可以并发执行，就把它们添加到一个并发队列中，让系统尽可能地同时执行它们。</li>
<li>run loop代码可以直接用一个串行队列或调度源实现。</li>
<li>如果对实时性要求非常严格，那么还是建议使用线程实现。</li>
</ul>

    </div>

    
    
    
        

  <div class="followme">
    <p>欢迎关注我的其它发布渠道</p>

    <div class="social-list">

        <div class="social-item">
          <a target="_blank" class="social-link" href="/atom.xml">
            <span class="icon">
              <i class="fa fa-rss"></i>
            </span>

            <span class="label">RSS</span>
          </a>
        </div>
    </div>
  </div>


      <footer class="post-footer">
          <div class="post-tags">
              <a href="/tags/Apple/" rel="tag"># Apple</a>
              <a href="/tags/%E5%A4%9A%E7%BA%BF%E7%A8%8B/" rel="tag"># 多线程</a>
              <a href="/tags/Concurrency-Programming-Guide/" rel="tag"># Concurrency Programming Guide</a>
          </div>

        


        
    <div class="post-nav">
      <div class="post-nav-item">
    <a href="/posts/concurrency_pg_dispatch_sources/" rel="prev" title="Concurrency Programming Guide：调度源">
      <i class="fa fa-chevron-left"></i> Concurrency Programming Guide：调度源
    </a></div>
      <div class="post-nav-item">
    <a href="/posts/concurrency_pg_glossary/" rel="next" title="Concurrency Programming Guide：术语表">
      Concurrency Programming Guide：术语表 <i class="fa fa-chevron-right"></i>
    </a></div>
    </div>
      </footer>
    
  </article>
  
  
  



          </div>
          
    <div class="comments" id="gitalk-container"></div>

<script>
  window.addEventListener('tabs:register', () => {
    let { activeClass } = CONFIG.comments;
    if (CONFIG.comments.storage) {
      activeClass = localStorage.getItem('comments_active') || activeClass;
    }
    if (activeClass) {
      let activeTab = document.querySelector(`a[href="#comment-${activeClass}"]`);
      if (activeTab) {
        activeTab.click();
      }
    }
  });
  if (CONFIG.comments.storage) {
    window.addEventListener('tabs:click', event => {
      if (!event.target.matches('.tabs-comment .tab-content .tab-pane')) return;
      let commentClass = event.target.classList[1];
      localStorage.setItem('comments_active', commentClass);
    });
  }
</script>

        </div>
          
  
  <div class="toggle sidebar-toggle">
    <span class="toggle-line toggle-line-first"></span>
    <span class="toggle-line toggle-line-middle"></span>
    <span class="toggle-line toggle-line-last"></span>
  </div>

  <aside class="sidebar">
    <div class="sidebar-inner">

      <ul class="sidebar-nav motion-element">
        <li class="sidebar-nav-toc">
          文章目录
        </li>
        <li class="sidebar-nav-overview">
          站点概览
        </li>
      </ul>

      <!--noindex-->
      <div class="post-toc-wrap sidebar-panel">
          <div class="post-toc motion-element"><ol class="nav"><li class="nav-item nav-level-2"><a class="nav-link" href="#%E7%94%A8%E8%B0%83%E5%BA%A6%E9%98%9F%E5%88%97%E6%9B%BF%E6%8D%A2%E7%BA%BF%E7%A8%8B"><span class="nav-text">用调度队列替换线程</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%B6%88%E9%99%A4%E5%9F%BA%E4%BA%8E%E9%94%81%E7%9A%84%E4%BB%A3%E7%A0%81"><span class="nav-text">消除基于锁的代码</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%AE%9E%E7%8E%B0%E5%BC%82%E6%AD%A5%E9%94%81"><span class="nav-text">实现异步锁</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%90%8C%E6%AD%A5%E6%89%A7%E8%A1%8C%E5%85%B3%E9%94%AE%E4%BB%A3%E7%A0%81"><span class="nav-text">同步执行关键代码</span></a></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%94%B9%E8%BF%9B%E5%BE%AA%E7%8E%AF%E4%BB%A3%E7%A0%81"><span class="nav-text">改进循环代码</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%9B%BF%E6%8D%A2%E7%BA%BF%E7%A8%8B%E8%BF%9E%E6%8E%A5"><span class="nav-text">替换线程连接</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%94%B9%E5%8F%98%E7%94%9F%E4%BA%A7%E8%80%85-%E6%B6%88%E8%B4%B9%E8%80%85%E7%9A%84%E5%AE%9E%E7%8E%B0%E6%96%B9%E5%BC%8F"><span class="nav-text">改变生产者-消费者的实现方式</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%9B%BF%E6%8D%A2%E4%BF%A1%E5%8F%B7%E9%87%8F%E4%BB%A3%E7%A0%81"><span class="nav-text">替换信号量代码</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%9B%BF%E6%8D%A2run-loop%E4%BB%A3%E7%A0%81"><span class="nav-text">替换Run-Loop代码</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E5%85%BC%E5%AE%B9posix%E7%BA%BF%E7%A8%8B"><span class="nav-text">兼容POSIX线程</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%80%BB%E7%BB%93"><span class="nav-text">总结</span></a></li></ol></div>
      </div>
      <!--/noindex-->

      <div class="site-overview-wrap sidebar-panel">
        <div class="site-author motion-element" itemprop="author" itemscope itemtype="http://schema.org/Person">
    <img class="site-author-image" itemprop="image" alt="權咚"
      src="/images/icon.png">
  <p class="site-author-name" itemprop="name">權咚</p>
  <div class="site-description" itemprop="description">🤘🤯👾</div>
</div>
<div class="site-state-wrap motion-element">
  <nav class="site-state">
      <div class="site-state-item site-state-posts">
          <a href="/archives/">
        
          <span class="site-state-item-count">84</span>
          <span class="site-state-item-name">文章</span>
        </a>
      </div>
      <div class="site-state-item site-state-categories">
            <a href="/categories/">
          
        <span class="site-state-item-count">6</span>
        <span class="site-state-item-name">分类</span></a>
      </div>
      <div class="site-state-item site-state-tags">
            <a href="/tags/">
          
        <span class="site-state-item-count">10</span>
        <span class="site-state-item-name">标签</span></a>
      </div>
  </nav>
</div>
  <div class="links-of-author motion-element">
      <span class="links-of-author-item">
        <a href="https://github.com/bqlin" title="GitHub → https:&#x2F;&#x2F;github.com&#x2F;bqlin" rel="noopener" target="_blank"><i class="fab fa-github fa-fw"></i>GitHub</a>
      </span>
      <span class="links-of-author-item">
        <a href="https://weibo.com/hearingdog" title="Weibo → https:&#x2F;&#x2F;weibo.com&#x2F;hearingdog" rel="noopener" target="_blank"><i class="fab fa-weibo fa-fw"></i>Weibo</a>
      </span>
  </div>


  <div class="links-of-blogroll motion-element">
    <div class="links-of-blogroll-title"><i class="fa fa-link fa-fw"></i>
      Links
    </div>
    <ul class="links-of-blogroll-list">
        <li class="links-of-blogroll-item">
          <a href="https://xiaozhuanlan.com/metal-reference-translation" title="https:&#x2F;&#x2F;xiaozhuanlan.com&#x2F;metal-reference-translation" rel="noopener" target="_blank">Metal内参</a>
        </li>
        <li class="links-of-blogroll-item">
          <a href="https://xiaozhuanlan.com/wwdc21" title="https:&#x2F;&#x2F;xiaozhuanlan.com&#x2F;wwdc21" rel="noopener" target="_blank">WWDC21 内参</a>
        </li>
    </ul>
  </div>

      </div>

    </div>
  </aside>
  <div id="sidebar-dimmer"></div>


      </div>
    </main>

    <footer class="footer">
      <div class="footer-inner">
        

        

<div class="copyright">
  
  &copy; 2016 – 
  <span itemprop="copyrightYear">2022</span>
  <span class="with-love">
    <i class="fa fa-heart"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">權咚</span>
    <span class="post-meta-divider">|</span>
    <span class="post-meta-item-icon">
      <i class="fa fa-chart-area"></i>
    </span>
    <span title="站点总字数">279k</span>
    <span class="post-meta-divider">|</span>
    <span class="post-meta-item-icon">
      <i class="fa fa-coffee"></i>
    </span>
    <span title="站点阅读时长">4:14</span>
</div>
  <div class="powered-by">由 <a href="https://hexo.io/" class="theme-link" rel="noopener" target="_blank">Hexo</a> & <a href="https://theme-next.org/" class="theme-link" rel="noopener" target="_blank">NexT.Gemini</a> 强力驱动
  </div>

        
<div class="busuanzi-count">
  <script async src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script>
    <span class="post-meta-item" id="busuanzi_container_site_uv" style="display: none;">
      <span class="post-meta-item-icon">
        <i class="fa fa-user"></i>
      </span>
      <span class="site-uv" title="总访客量">
        <span id="busuanzi_value_site_uv"></span>
      </span>
    </span>
    <span class="post-meta-divider">|</span>
    <span class="post-meta-item" id="busuanzi_container_site_pv" style="display: none;">
      <span class="post-meta-item-icon">
        <i class="fa fa-eye"></i>
      </span>
      <span class="site-pv" title="总访问量">
        <span id="busuanzi_value_site_pv"></span>
      </span>
    </span>
</div>








      </div>
    </footer>
  </div>

  
  <script src="/lib/anime.min.js"></script>
  <script src="//cdn.jsdelivr.net/npm/pangu@4/dist/browser/pangu.min.js"></script>

<script src="/js/utils.js"></script>


<script src="/js/schemes/pisces.js"></script>


<script src="/js/next-boot.js"></script>




  
  <script>
    (function(){
      var canonicalURL, curProtocol;
      //Get the <link> tag
      var x=document.getElementsByTagName("link");
		//Find the last canonical URL
		if(x.length > 0){
			for (i=0;i<x.length;i++){
				if(x[i].rel.toLowerCase() == 'canonical' && x[i].href){
					canonicalURL=x[i].href;
				}
			}
		}
    //Get protocol
	    if (!canonicalURL){
	    	curProtocol = window.location.protocol.split(':')[0];
	    }
	    else{
	    	curProtocol = canonicalURL.split(':')[0];
	    }
      //Get current URL if the canonical URL does not exist
	    if (!canonicalURL) canonicalURL = window.location.href;
	    //Assign script content. Replace current URL with the canonical URL
      !function(){var e=/([http|https]:\/\/[a-zA-Z0-9\_\.]+\.baidu\.com)/gi,r=canonicalURL,t=document.referrer;if(!e.test(r)){var n=(String(curProtocol).toLowerCase() === 'https')?"https://sp0.baidu.com/9_Q4simg2RQJ8t7jm9iCKT-xh_/s.gif":"//api.share.baidu.com/s.gif";t?(n+="?r="+encodeURIComponent(document.referrer),r&&(n+="&l="+r)):r&&(n+="?l="+r);var i=new Image;i.src=n}}(window);})();
  </script>




  
<script src="/js/local-search.js"></script>











<script>
if (document.querySelectorAll('pre.mermaid').length) {
  NexT.utils.getScript('//cdn.jsdelivr.net/npm/mermaid@8/dist/mermaid.min.js', () => {
    mermaid.initialize({
      theme    : 'default',
      logLevel : 3,
      flowchart: { curve     : 'linear' },
      gantt    : { axisFormat: '%m/%d/%Y' },
      sequence : { actorMargin: 50 }
    });
  }, window.mermaid);
}
</script>


  

  

  

<link rel="stylesheet" href="//cdn.jsdelivr.net/npm/gitalk@1/dist/gitalk.min.css">

<script>
NexT.utils.loadComments(document.querySelector('#gitalk-container'), () => {
  NexT.utils.getScript('//cdn.jsdelivr.net/npm/gitalk@1/dist/gitalk.min.js', () => {
    var gitalk = new Gitalk({
      clientID    : '7ed324dbfd2741c35c0e',
      clientSecret: '75a59e1f6a55202c4a1b0ec3570ad5b5dccbc390',
      repo        : 'bqlin.github.io',
      owner       : 'bqlin',
      admin       : ['bqlin'],
      id          : 'ea7ffac539fe4a5ab542d5e2ef675cba',
        language: 'zh-CN',
      distractionFreeMode: true
    });
    gitalk.render('gitalk-container');
  }, window.Gitalk);
});
</script>

<script src="/live2dw/lib/L2Dwidget.min.js?094cbace49a39548bed64abff5988b05"></script><script>L2Dwidget.init({"pluginRootPath":"live2dw/","pluginJsPath":"lib/","pluginModelPath":"assets/","tagMode":false,"debug":false,"model":{"scale":1,"jsonPath":"/live2dw/assets/hijiki.model.json"},"display":{"position":"right","vOffset":-100},"mobile":{"show":false,"scale":0.5},"log":false});</script></body>
</html>
